<?php

/**
 * @see Database_Select
 */
require_once 'database/select.php';

/**
 * Class for connecting to SQL databases and performing common operations.
 *
 * @category   Zend
 * @package    Db
 * @subpackage Adapter
 * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc.
 * (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
abstract class Database_Adapter
{

	/**
	 * User-provided configuration
	 *
	 * @var array
	 */
	protected $_config = array();

	/**
	 * @var bool
	 */
	protected $_replicated = FALSE;

	/**
	 * Fetch mode
	 *
	 * @var integer
	 */
	protected $_fetchMode = Database::FETCH_ASSOC;

	/**
	 * Database connection
	 *
	 * @var object|resource|null
	 */
	protected $_connection = null;

	/**
	 * Database connection
	 *
	 * @var object|resource|null
	 */
	protected $_slaveConnection = null;

	/**
	 * @var bool
	 */
	protected $_autoQuoteIdentifiers = FALSE;

	/**
	 * Keys are UPPERCASE SQL datatypes or the constants
	 * Database::INT_TYPE, Database::BIGINT_TYPE, or Database::FLOAT_TYPE.
	 *
	 * Values are:
	 * 0 = 32-bit integer
	 * 1 = 64-bit integer
	 * 2 = float or decimal
	 *
	 * @var array Associative array of datatypes to values 0, 1, or 2.
	 */
	protected $_numericDataTypes = array(
		Database::INT_TYPE => Database::INT_TYPE,
		Database::BIGINT_TYPE => Database::BIGINT_TYPE,
		Database::FLOAT_TYPE => Database::FLOAT_TYPE
	);

	/** Weither or not that object can get serialized
	 *
	 * @var bool
	 */
	protected $_allowSerialization = true;

	/**
	 * Weither or not the database should be reconnected
	 * to that adapter when waking up
	 *
	 * @var bool
	 */
	protected $_autoReconnectOnUnserialize = false;

	/**
	 * @link config/mysql.php to check more information how to configure mysql that
	 * support master/slave or single use only.
	 *
	 * dbname         => (string) The name of the database to user
	 * username       => (string) Connect to the database as this username.
	 * password       => (string) Password associated with the username.
	 * host           => (string) What host to connect to, defaults to localhost
	 * array master/slave
	 *
	 * @param  array $config configuration data
	 * @throws Database_Exception
	 */
	public function __construct($config)
	{
		
		$this -> _replicated = isset($config['slaves']) && count($config['slaves']);

		$options = array(Database::AUTO_QUOTE_IDENTIFIERS => 1);

		$driverOptions = array();

		/*
		 * normalize the config and merge it with the defaults
		 */
		if (array_key_exists('options', $config))
		{
			// can't use array_merge() because keys might be integers
			foreach ((array) $config['options'] as $key => $value)
			{
				$options[$key] = $value;
			}
		}
		if (array_key_exists('driver_options', $config))
		{
			if (!empty($config['driver_options']))
			{
				// can't use array_merge() because keys might be integers
				foreach ((array) $config['driver_options'] as $key => $value)
				{
					$driverOptions[$key] = $value;
				}
			}
		}

		if (!isset($config['charset']))
		{
			$config['charset'] = null;
		}

		if (!isset($config['persistent']))
		{
			$config['persistent'] = false;
		}

		$this -> _config = array_merge($this -> _config, $config);
		$this -> _config['options'] = $options;
		$this -> _config['driver_options'] = $driverOptions;
	}

	/**
	 * Returns the configuration variables in this adapter.
	 * @param string $name
	 * @param any $default
	 * @return any
	 */
	public function getConfig($name = NULL, $default = NULL)
	{
		if (NULL == $name)
		{
			return $this -> _config;
		}
		return isset($this -> _config[$name]) ? $this -> _config[$name] : $default;
	}

	/**
	 * get master or slave connection
	 * by default it return master connection
	 * @param string $slave
	 * @return object|resource|null
	 *
	 */
	public function getConnection($slave = FALSE)
	{
		if ($this -> _replicated and $slave == TRUE)
		{
			$this -> _connectSlave();
			return $this -> _slaveConnection;
		}

		$this -> _connect();
		return $this -> _connection;

	}

	/**
	 * Prepares and executes an SQL statement with bound data.
	 *
	 * @param  mixed  $sql  The SQL statement with placeholders.
	 *                      May be a string or Database_Select.
	 * @param  mixed  $bind An array of data to bind to the placeholders.
	 * @return Database_Statement_Interface
	 */
	public function query($sql, $bind = array())
	{

		// is the $sql a Database_Select object?
		if ($sql instanceof Database_Select)
		{
			if (empty($bind))
			{
				$bind = $sql -> getBind();
			}

			$sql = $sql -> assemble();
		}

		// make sure $bind to an array;
		// don't use (array) typecasting because
		// because $bind may be a Database_Expr object
		if (!is_array($bind))
		{
			$bind = array($bind);
		}

		// prepare and execute the statement with profiling
		$stmt = $this -> prepare($sql);

		$stmt -> execute($bind);

		// return the results embedded in the prepared statement object
		$stmt -> setFetchMode($this -> _fetchMode);
		return $stmt;
	}

	/**
	 * Leave autocommit mode and begin a transaction.
	 *
	 * @return Database_Adapter
	 */
	public function beginTransaction()
	{
		$this -> _connect();

		if (PROFILLING)
		{
			$token = Profiler::start('sql', 'begin transaction');
		}

		$this -> _beginTransaction();

		if (PROFILLING)
		{
			Profiler::stop($token);
		}
		return $this;
	}

	/**
	 * Commit a transaction and return to autocommit mode.
	 *
	 * @return Database_Adapter
	 */
	public function commit()
	{
		$this -> _connect();

		if (PROFILLING)
		{
			$token = Profiler::start('sql', 'commit');
		}

		$this -> _commit();

		if (PROFILLING)
		{
			Profiler::stop($token);
		}
		return $this;
	}

	/**
	 * Roll back a transaction and return to autocommit mode.
	 *
	 * @return Database_Adapter
	 */
	public function rollBack()
	{
		$this -> _connect();

		if (PROFILLING)
		{
			$token = Profiler::start('sql', 'rollback');
		}

		$this -> _rollBack();

		if (PROFILLING)
		{
			Profiler::stop($token);
		}
		return $this;
	}

	/**
	 * Inserts a table row with specified data.
	 *
	 * @param mixed $table The table to insert data into.
	 * @param array $bind Column-value pairs.
	 * @return int The number of affected rows.
	 */
	public function insert($table, array $bind)
	{
		// extract and quote col names from the array keys
		$cols = array();
		$vals = array();
		foreach ($bind as $col => $val)
		{
			$cols[] = $this -> quoteIdentifier($col, true);
			if ($val instanceof Database_Expr)
			{
				$vals[] = $val -> __toString();
				unset($bind[$col]);
			}
			else
			{
				$vals[] = '?';
			}
		}

		// build the statement
		$sql = "INSERT INTO " . $this -> quoteIdentifier($table, true) . ' (' . implode(', ', $cols) . ') ' . 'VALUES (' . implode(', ', $vals) . ')';

		// execute the statement and return the number of affected rows
		$stmt = $this -> query($sql, array_values($bind));
		$result = $stmt -> rowCount();
		return $result;
	}

	/**
	 * Updates table rows with specified data based on a WHERE clause.
	 *
	 * @param  mixed        $table The table to update.
	 * @param  array        $bind  Column-value pairs.
	 * @param  mixed        $where UPDATE WHERE clause(s).
	 * @return int          The number of affected rows.
	 */
	public function update($table, array $bind, $where = '')
	{
		/**
		 * Build "col = ?" pairs for the statement,
		 * except for Database_Expr which is treated literally.
		 */
		$set = array();
		$i = 0;
		foreach ($bind as $col => $val)
		{
			if ($val instanceof Database_Expr)
			{
				$val = $val -> __toString();
				unset($bind[$col]);
			}
			else
			{
				if ($this -> supportsParameters('positional'))
				{
					$val = '?';
				}
				else
				{
					if ($this -> supportsParameters('named'))
					{
						unset($bind[$col]);
						$bind[':' . $col . $i] = $val;
						$val = ':' . $col . $i;
						$i++;
					}
					else
					{
						/** @see Database_Exception */

						throw new Database_Exception(get_class($this) . " doesn't support positional or named binding");
					}
				}
			}
			$set[] = $this -> quoteIdentifier($col, true) . ' = ' . $val;
		}

		$where = $this -> _whereExpr($where);

		/**
		 * Build the UPDATE statement
		 */
		$sql = "UPDATE " . $this -> quoteIdentifier($table, true) . ' SET ' . implode(', ', $set) . (($where) ? " WHERE $where" : '');

		/**
		 * Execute the statement and return the number of affected rows
		 */
		if ($this -> supportsParameters('positional'))
		{
			$stmt = $this -> query($sql, array_values($bind));
		}
		else
		{
			$stmt = $this -> query($sql, $bind);
		}
		$result = $stmt -> rowCount();
		return $result;
	}

	/**
	 * Deletes table rows based on a WHERE clause.
	 *
	 * @param  mixed        $table The table to update.
	 * @param  mixed        $where DELETE WHERE clause(s).
	 * @return int          The number of affected rows.
	 */
	public function delete($table, $where = '')
	{
		$where = $this -> _whereExpr($where);

		/**
		 * Build the DELETE statement
		 */
		$sql = "DELETE FROM " . $this -> quoteIdentifier($table, true) . (($where) ? " WHERE $where" : '');

		/**
		 * Execute the statement and return the number of affected rows
		 */
		$stmt = $this -> query($sql);
		$result = $stmt -> rowCount();
		return $result;
	}

	/**
	 * Convert an array, string, or Database_Expr object
	 * into a string to put in a WHERE clause.
	 *
	 * @param mixed $where
	 * @return string
	 */
	protected function _whereExpr($where)
	{
		if (empty($where))
		{
			return $where;
		}
		if (!is_array($where))
		{
			$where = array($where);
		}
		foreach ($where as $cond => &$term)
		{
			// is $cond an int? (i.e. Not a condition)
			if (is_int($cond))
			{
				// $term is the full condition
				if ($term instanceof Database_Expr)
				{
					$term = $term -> __toString();
				}
			}
			else
			{
				// $cond is the condition with placeholder,
				// and $term is quoted into the condition
				$term = $this -> quoteInto($cond, $term);
			}
			$term = '(' . $term . ')';
		}

		$where = implode(' AND ', $where);
		return $where;
	}

	/**
	 * Creates and returns a new Database_Select object for this adapter.
	 *
	 * @return Database_Select
	 */
	public function select()
	{
		return new Database_Select($this);
	}

	/**
	 * Get the fetch mode.
	 *
	 * @return int
	 */
	public function getFetchMode()
	{
		return $this -> _fetchMode;
	}

	/**
	 * Fetches all SQL result rows as a sequential array.
	 * Uses the current fetchMode for the adapter.
	 *
	 * @param string|Database_Select $sql  An SQL SELECT statement.
	 * @param mixed                 $bind Data to bind into SELECT placeholders.
	 * @param mixed                 $fetchMode Override current fetch mode.
	 * @return array
	 */
	public function fetchAll($sql, $bind = array(), $fetchMode = null)
	{
		if ($fetchMode === null)
		{
			$fetchMode = $this -> _fetchMode;
		}
		$stmt = $this -> query($sql, $bind);
		$result = $stmt -> fetchAll($fetchMode);
		return $result;
	}

	/**
	 * Fetches the first row of the SQL result.
	 * Uses the current fetchMode for the adapter.
	 *
	 * @param string|Database_Select $sql An SQL SELECT statement.
	 * @param mixed $bind Data to bind into SELECT placeholders.
	 * @param mixed                 $fetchMode Override current fetch mode.
	 * @return array
	 */
	public function fetchRow($sql, $bind = array(), $fetchMode = null)
	{
		if ($fetchMode === null)
		{
			$fetchMode = $this -> _fetchMode;
		}
		$stmt = $this -> query($sql, $bind);
		$result = $stmt -> fetch($fetchMode);
		return $result;
	}

	/**
	 * Fetches all SQL result rows as an associative array.
	 *
	 * The first column is the key, the entire row array is the
	 * value.  You should construct the query to be sure that
	 * the first column contains unique values, or else
	 * rows with duplicate values in the first column will
	 * overwrite previous data.
	 *
	 * @param string|Database_Select $sql An SQL SELECT statement.
	 * @param mixed $bind Data to bind into SELECT placeholders.
	 * @return array
	 */
	public function fetchAssoc($sql, $bind = array())
	{
		$stmt = $this -> query($sql, $bind);
		$data = array();
		while ($row = $stmt -> fetch(Database::FETCH_ASSOC))
		{
			$tmp = array_values(array_slice($row, 0, 1));
			$data[$tmp[0]] = $row;
		}
		return $data;
	}

	/**
	 * Fetches the first column of all SQL result rows as an array.
	 *
	 * The first column in each row is used as the array key.
	 *
	 * @param string|Database_Select $sql An SQL SELECT statement.
	 * @param mixed $bind Data to bind into SELECT placeholders.
	 * @return array
	 */
	public function fetchCol($sql, $bind = array())
	{
		$stmt = $this -> query($sql, $bind);
		$result = $stmt -> fetchAll(Database::FETCH_COLUMN, 0);
		return $result;
	}

	/**
	 * Fetches all SQL result rows as an array of key-value pairs.
	 *
	 * The first column is the key, the second column is the
	 * value.
	 *
	 * @param string|Database_Select $sql An SQL SELECT statement.
	 * @param mixed $bind Data to bind into SELECT placeholders.
	 * @return array
	 */
	public function fetchPairs($sql, $bind = array())
	{
		$stmt = $this -> query($sql, $bind);
		$data = array();
		while ($row = $stmt -> fetch(Database::FETCH_NUM))
		{
			$data[$row[0]] = $row[1];
		}
		return $data;
	}

	/**
	 * Fetches the first column of the first row of the SQL result.
	 *
	 * @param string|Database_Select $sql An SQL SELECT statement.
	 * @param mixed $bind Data to bind into SELECT placeholders.
	 * @return string
	 */
	public function fetchOne($sql, $bind = array())
	{
		$stmt = $this -> query($sql, $bind);
		$result = $stmt -> fetchColumn(0);
		return $result;
	}

	/**
	 * Quote a raw string.
	 *
	 * @param string $value     Raw string
	 * @return string           Quoted string
	 */
	protected function _quote($value)
	{
		if (is_int($value))
		{
			return $value;
		}
		elseif (is_float($value))
		{
			return sprintf('%F', $value);
		}
		return "'" . addcslashes($value, "\000\n\r\\'\"\032") . "'";
	}

	/**
	 * Safely quotes a value for an SQL statement.
	 *
	 * If an array is passed as the value, the array values are quoted
	 * and then returned as a comma-separated string.
	 *
	 * @param mixed $value The value to quote.
	 * @param mixed $type  OPTIONAL the SQL datatype name, or constant, or null.
	 * @return mixed An SQL-safe quoted value (or string of separated values).
	 */
	public function quote($value, $type = null)
	{
		$this -> _connect();

		if ($value instanceof Database_Select)
		{
			return '(' . $value -> assemble() . ')';
		}

		if ($value instanceof Database_Expr)
		{
			return $value -> __toString();
		}

		if (is_array($value))
		{
			foreach ($value as &$val)
			{
				$val = $this -> quote($val, $type);
			}
			return implode(', ', $value);
		}

		if ($type !== null && array_key_exists($type = strtoupper($type), $this -> _numericDataTypes))
		{
			$quotedValue = '0';
			switch ($this->_numericDataTypes[$type])
			{
				case Database::INT_TYPE :
					// 32-bit integer
					$quotedValue = (string) intval($value);
					break;
				case Database::BIGINT_TYPE :
					// 64-bit integer
					// ANSI SQL-style hex literals (e.g. x'[\dA-F]+')
					// are not supported here, because these are string
					// literals, not numeric literals.
					if (preg_match('/^(
                          [+-]?                  # optional sign
                          (?:
                            0[Xx][\da-fA-F]+     # ODBC-style hexadecimal
                            |\d+                 # decimal or octal, or MySQL ZEROFILL decimal
                            (?:[eE][+-]?\d+)?    # optional exponent on decimals or octals
                          )
                        )/x', (string)$value, $matches))
					{
						$quotedValue = $matches[1];
					}
					break;
				case Database::FLOAT_TYPE :
					// float or decimal
					$quotedValue = sprintf('%F', $value);
			}
			return $quotedValue;
		}

		return $this -> _quote($value);
	}

	/**
	 * Quotes a value and places into a piece of text at a placeholder.
	 *
	 * The placeholder is a question-mark; all placeholders will be replaced
	 * with the quoted value.   For example:
	 *
	 * <code>
	 * $text = "WHERE date < ?";
	 * $date = "2005-01-02";
	 * $safe = $sql->quoteInto($text, $date);
	 * // $safe = "WHERE date < '2005-01-02'"
	 * </code>
	 *
	 * @param string  $text  The text with a placeholder.
	 * @param mixed   $value The value to quote.
	 * @param string  $type  OPTIONAL SQL datatype
	 * @param integer $count OPTIONAL count of placeholders to replace
	 * @return string An SQL-safe quoted value placed into the original text.
	 */
	public function quoteInto($text, $value, $type = null, $count = null)
	{
		if ($count === null)
		{
			return str_replace('?', $this -> quote($value, $type), $text);
		}
		else
		{
			while ($count > 0)
			{
				if (strpos($text, '?') !== false)
				{
					$text = substr_replace($text, $this -> quote($value, $type), strpos($text, '?'), 1);
				}
				--$count;
			}
			return $text;
		}
	}

	/**
	 * Quotes an identifier.
	 *
	 * Accepts a string representing a qualified indentifier. For Example:
	 * <code>
	 * $adapter->quoteIdentifier('myschema.mytable')
	 * </code>
	 * Returns: "myschema"."mytable"
	 *
	 * Or, an array of one or more identifiers that may form a qualified identifier:
	 * <code>
	 * $adapter->quoteIdentifier(array('myschema','my.table'))
	 * </code>
	 * Returns: "myschema"."my.table"
	 *
	 * The actual quote character surrounding the identifiers may vary depending on
	 * the adapter.
	 *
	 * @param string|array|Database_Expr $ident The identifier.
	 * @param boolean $auto If true, heed the AUTO_QUOTE_IDENTIFIERS config option.
	 * @return string The quoted identifier.
	 */
	public function quoteIdentifier($ident, $auto = false)
	{
		return $this -> _quoteIdentifierAs($ident, null, $auto);
	}

	/**
	 * Quote a column identifier and alias.
	 *
	 * @param string|array|Database_Expr $ident The identifier or expression.
	 * @param string $alias An alias for the column.
	 * @param boolean $auto If true, heed the AUTO_QUOTE_IDENTIFIERS config option.
	 * @return string The quoted identifier and alias.
	 */
	public function quoteColumnAs($ident, $alias, $auto = false)
	{
		return $this -> _quoteIdentifierAs($ident, $alias, $auto);
	}

	/**
	 * Quote a table identifier and alias.
	 *
	 * @param string|array|Database_Expr $ident The identifier or expression.
	 * @param string $alias An alias for the table.
	 * @param boolean $auto If true, heed the AUTO_QUOTE_IDENTIFIERS config option.
	 * @return string The quoted identifier and alias.
	 */
	public function quoteTableAs($ident, $alias = null, $auto = false)
	{
		return $this -> _quoteIdentifierAs($ident, $alias, $auto);
	}

	/**
	 * Quote an identifier and an optional alias.
	 *
	 * @param string|array|Database_Expr $ident The identifier or expression.
	 * @param string $alias An optional alias.
	 * @param boolean $auto If true, heed the AUTO_QUOTE_IDENTIFIERS config option.
	 * @param string $as The string to add between the identifier/expression and the
	 * alias.
	 * @return string The quoted identifier and alias.
	 */
	protected function _quoteIdentifierAs($ident, $alias = null, $auto = false, $as = ' AS ')
	{
		if ($ident instanceof Database_Expr)
		{
			$quoted = $ident -> __toString();
		}
		elseif ($ident instanceof Database_Select)
		{
			$quoted = '(' . $ident -> assemble() . ')';
		}
		else
		{
			if (is_string($ident))
			{
				$ident = explode('.', $ident);
			}
			if (is_array($ident))
			{
				$segments = array();
				foreach ($ident as $segment)
				{
					if ($segment instanceof Database_Expr)
					{
						$segments[] = $segment -> __toString();
					}
					else
					{
						$segments[] = $this -> _quoteIdentifier($segment, $auto);
					}
				}
				if ($alias !== null && end($ident) == $alias)
				{
					$alias = null;
				}
				$quoted = implode('.', $segments);
			}
			else
			{
				$quoted = $this -> _quoteIdentifier($ident, $auto);
			}
		}
		if ($alias !== null)
		{
			$quoted .= $as . $this -> _quoteIdentifier($alias, $auto);
		}
		return $quoted;
	}

	/**
	 * Quote an identifier.
	 *
	 * @param  string $value The identifier or expression.
	 * @param boolean $auto If true, heed the AUTO_QUOTE_IDENTIFIERS config option.
	 * @return string        The quoted identifier and alias.
	 */
	protected function _quoteIdentifier($value, $auto = false)
	{
		if ($auto === false || $this -> _autoQuoteIdentifiers === true)
		{
			$q = $this -> getQuoteIdentifierSymbol();
			return ($q . str_replace("$q", "$q$q", $value) . $q);
		}

		return $value;
	}

	/**
	 * Returns the symbol the adapter uses for delimited identifiers.
	 *
	 * @return string
	 */
	public function getQuoteIdentifierSymbol()
	{
		return '"';
	}

	/**
	 * Return the most recent value from the specified sequence in the database.
	 * This is supported only on RDBMS brands that support sequences
	 * (e.g. Oracle, PostgreSQL, DB2).  Other RDBMS brands return null.
	 *
	 * @param string $sequenceName
	 * @return string
	 */
	public function lastSequenceId($sequenceName)
	{
		return null;
	}

	/**
	 * Generate a new value from the specified sequence in the database, and return
	 * it.
	 * This is supported only on RDBMS brands that support sequences
	 * (e.g. Oracle, PostgreSQL, DB2).  Other RDBMS brands return null.
	 *
	 * @param string $sequenceName
	 * @return string
	 */
	public function nextSequenceId($sequenceName)
	{
		return null;
	}

	/**
	 * called when object is getting serialized
	 * This disconnects the DB object that cant be serialized
	 *
	 * @throws Database_Exception
	 * @return array
	 */
	public function __sleep()
	{
		if ($this -> _allowSerialization == false)
		{
			throw new Database_Exception("could not serialize {cls}", array('{cls}' => get_class($this)));
		}
		$this -> _connection = false;
		return array_keys(array_diff_key(get_object_vars($this), array('_connection' => false)));
	}

	/**
	 * called when object is getting unserialized
	 *
	 * @return void
	 */
	public function __wakeup()
	{
		if ($this -> _autoReconnectOnUnserialize == true)
		{
			$this -> getConnection();
		}
	}

	/**
	 * Abstract Methods
	 */

	/**
	 * Returns a list of the tables in the database.
	 *
	 * @return array
	 */
	abstract public function listTables();

	/**
	 * Returns the column descriptions for a table.
	 *
	 * The return value is an associative array keyed by the column name,
	 * as returned by the RDBMS.
	 *
	 * The value of each array element is an associative array
	 * with the following keys:
	 *
	 * SCHEMA_NAME => string; name of database or schema
	 * TABLE_NAME  => string;
	 * COLUMN_NAME => string; column name
	 * COLUMN_POSITION => number; ordinal position of column in table
	 * DATA_TYPE   => string; SQL datatype name of column
	 * DEFAULT     => string; default expression of column, null if none
	 * NULLABLE    => boolean; true if column can have nulls
	 * LENGTH      => number; length of CHAR/VARCHAR
	 * SCALE       => number; scale of NUMERIC/DECIMAL
	 * PRECISION   => number; precision of NUMERIC/DECIMAL
	 * UNSIGNED    => boolean; unsigned property of an integer type
	 * PRIMARY     => boolean; true if column is part of the primary key
	 * PRIMARY_POSITION => integer; position of column in primary key
	 *
	 * @param string $tableName
	 * @param string $schemaName OPTIONAL
	 * @return array
	 */
	abstract public function describeTable($tableName, $schemaName = null);

	/**
	 * Creates a connection to the database.
	 *
	 * @return void
	 */
	abstract protected function _connect();

	/**
	 * Creates a connection to the database.
	 *
	 * @return void
	 */
	abstract protected function _connectSlave();

	/**
	 * Test if a connection is active
	 *
	 * @return boolean
	 */
	abstract public function isConnected();

	/**
	 * Force the connection to close.
	 *
	 * @return void
	 */
	abstract public function closeConnection();

	/**
	 * Prepare a statement and return a PDOStatement-like object.
	 *
	 * @param string|Database_Select $sql SQL query
	 * @return Database_Statement|PDOStatement
	 */
	abstract public function prepare($sql);

	/**
	 * Gets the last ID generated automatically by an IDENTITY/AUTOINCREMENT column.
	 *
	 * As a convention, on RDBMS brands that support sequences
	 * (e.g. Oracle, PostgreSQL, DB2), this method forms the name of a sequence
	 * from the arguments and returns the last id generated by that sequence.
	 * On RDBMS brands that support IDENTITY/AUTOINCREMENT columns, this method
	 * returns the last value generated for such a column, and the table name
	 * argument is disregarded.
	 *
	 * @param string $tableName   OPTIONAL Name of table.
	 * @param string $primaryKey  OPTIONAL Name of primary key column.
	 * @return string
	 */
	abstract public function lastInsertId($tableName = null, $primaryKey = null);

	/**
	 * Begin a transaction.
	 */
	abstract protected function _beginTransaction();

	/**
	 * Commit a transaction.
	 */
	abstract protected function _commit();

	/**
	 * Roll-back a transaction.
	 */
	abstract protected function _rollBack();

	/**
	 * Set the fetch mode.
	 *
	 * @param integer $mode
	 * @return void
	 * @throws Database_Exception
	 */
	abstract public function setFetchMode($mode);

	/**
	 * Adds an adapter-specific LIMIT clause to the SELECT statement.
	 *
	 * @param mixed $sql
	 * @param integer $count
	 * @param integer $offset
	 * @return string
	 */
	abstract public function limit($sql, $count, $offset = 0);

	/**
	 * Check if the adapter supports real SQL parameters.
	 *
	 * @param string $type 'positional' or 'named'
	 * @return bool
	 */
	abstract public function supportsParameters($type);

	/**
	 * Retrieve server version in PHP style
	 *
	 * @return string
	 */
	abstract public function getServerVersion();
}
